Scrape tools config lazily

diff --git a/src/bin/cargo.rs b/src/bin/cargo.rs
index d29a3cbb06feb9b2b946cef7fdf1a38b6b6d4372..effef0490a6537b5b052b2e0d026fd1250c73da5 100644 (file)
--- a/src/bin/cargo.rs
+++ b/src/bin/cargo.rs
@@ -150,8 +150,9 @@ fn execute(flags: Flags, config: &Config) -> CliResult<Option<()>> {
     }
 
     if let Some(ref code) = flags.flag_explain {
-        try!(process(config.rustc()).arg("--explain").arg(code).exec()
-                                    .map_err(human));
+        try!(process(&*try!(config.rustc()))
+                 .arg("--explain").arg(code).exec()
+                 .map_err(human));
         return Ok(None)
     }
 

diff --git a/src/cargo/ops/cargo_rustc/context.rs b/src/cargo/ops/cargo_rustc/context.rs
index 0736d9fe68c889d9ad20f9b4c41fe95148a26f63..c46b9170daafd28ed0c283d445c0b71cdb4ef3c0 100644 (file)
--- a/src/cargo/ops/cargo_rustc/context.rs
+++ b/src/cargo/ops/cargo_rustc/context.rs
@@ -166,7 +166,7 @@ impl<'a, 'cfg> Context<'a, 'cfg> {
                                       &self.build_config,
                                       kind,
                                       "RUSTFLAGS"));
-        let mut process = util::process(self.config.rustc());
+        let mut process = util::process(&*try!(self.config.rustc()));
         process.arg("-")
                .arg("--crate-name").arg("_")
                .arg("--print=file-names")

diff --git a/src/cargo/ops/cargo_rustc/custom_build.rs b/src/cargo/ops/cargo_rustc/custom_build.rs
index 868f07a8f5d96c1b1629af34de76bd60272ea3f7..b0fd0ea5e4f4c15f54b44f2ad8b501124b387422 100644 (file)
--- a/src/cargo/ops/cargo_rustc/custom_build.rs
+++ b/src/cargo/ops/cargo_rustc/custom_build.rs
@@ -113,8 +113,8 @@ fn build_work<'a, 'cfg>(cx: &mut Context<'a, 'cfg>, unit: &Unit<'a>)
      .env("OPT_LEVEL", &profile.opt_level.to_string())
      .env("PROFILE", if cx.build_config.release {"release"} else {"debug"})
      .env("HOST", cx.host_triple())
-     .env("RUSTC", &cx.config.rustc())
-     .env("RUSTDOC", &cx.config.rustdoc());
+     .env("RUSTC", &*try!(cx.config.rustc()))
+     .env("RUSTDOC", &*try!(cx.config.rustdoc()));
 
      if let Some(links) = unit.pkg.manifest().links(){
         p.env("CARGO_MANIFEST_LINKS", links);

diff --git a/src/cargo/ops/cargo_rustc/engine.rs b/src/cargo/ops/cargo_rustc/engine.rs
index 9b5a3194326e4583bbb19a4e447574ff816132dd..76f5d3914f34f365231f0ea29b02db4dd78576cd 100644 (file)
--- a/src/cargo/ops/cargo_rustc/engine.rs
+++ b/src/cargo/ops/cargo_rustc/engine.rs
@@ -41,8 +41,8 @@ impl CommandPrototype {
         Ok(CommandPrototype {
             builder: {
                 let mut p = match ty {
-                    CommandType::Rustc => process(config.rustc()),
-                    CommandType::Rustdoc => process(config.rustdoc()),
+                    CommandType::Rustc => process(&*try!(config.rustc())),
+                    CommandType::Rustdoc => process(&*try!(config.rustdoc())),
                     CommandType::Target(ref s) |
                     CommandType::Host(ref s) => process(s),
                 };

diff --git a/src/cargo/util/config.rs b/src/cargo/util/config.rs
index d1b299e5f4684d67f59d537b2531b368f9da6dc4..28e9228d2db5c0bd71da9416bf860fe87d53e0e9 100644 (file)
--- a/src/cargo/util/config.rs
+++ b/src/cargo/util/config.rs
@@ -28,8 +28,8 @@ pub struct Config {
     values: RefCell<HashMap<String, ConfigValue>>,
     values_loaded: Cell<bool>,
     cwd: PathBuf,
-    rustc: PathBuf,
-    rustdoc: PathBuf,
+    rustc: RefCell<Option<PathBuf>>,
+    rustdoc: RefCell<Option<PathBuf>>,
     target_dir: RefCell<Option<Filesystem>>,
     extra_verbose: Cell<bool>,
     frozen: Cell<bool>,
@@ -47,15 +47,14 @@ impl Config {
             cwd: cwd,
             values: RefCell::new(HashMap::new()),
             values_loaded: Cell::new(false),
-            rustc: PathBuf::from("rustc"),
-            rustdoc: PathBuf::from("rustdoc"),
+            rustc: RefCell::new(None),
+            rustdoc: RefCell::new(None),
             target_dir: RefCell::new(None),
             extra_verbose: Cell::new(false),
             frozen: Cell::new(false),
             locked: Cell::new(false),
         };
 
-        try!(cfg.scrape_tool_config());
         try!(cfg.scrape_target_dir_config());
 
         Ok(cfg)
@@ -99,13 +98,24 @@ impl Config {
         self.shell.borrow_mut()
     }
 
-    pub fn rustc(&self) -> &Path { &self.rustc }
+    pub fn rustc(&self) -> CargoResult<Ref<Path>> {
+        if self.rustc.borrow().is_none() {
+            *self.rustc.borrow_mut() = Some(try!(self.get_tool("rustc")));
+        }
+        Ok(Ref::map(self.rustc.borrow(), |opt| opt.as_ref().map(AsRef::as_ref).unwrap()))
+    }
 
-    pub fn rustdoc(&self) -> &Path { &self.rustdoc }
+    pub fn rustdoc(&self) -> CargoResult<Ref<Path>> {
+        if self.rustdoc.borrow().is_none() {
+            *self.rustdoc.borrow_mut() = Some(try!(self.get_tool("rustdoc")));
+        }
+        Ok(Ref::map(self.rustdoc.borrow(), |opt| opt.as_ref().map(AsRef::as_ref).unwrap()))
+    }
 
     pub fn rustc_info(&self) -> CargoResult<Ref<Rustc>> {
         if self.rustc_info.borrow().is_none() {
-            *self.rustc_info.borrow_mut() = Some(try!(Rustc::new(&self.rustc)));
+            let path = try!(self.rustc());
+            *self.rustc_info.borrow_mut() = Some(try!(Rustc::new(&*path)));
         }
         Ok(Ref::map(self.rustc_info.borrow(), |opt| opt.as_ref().unwrap()))
     }
@@ -382,12 +392,6 @@ impl Config {
         Ok(())
     }
 
-    fn scrape_tool_config(&mut self) -> CargoResult<()> {
-        self.rustc = try!(self.get_tool("rustc"));
-        self.rustdoc = try!(self.get_tool("rustdoc"));
-        Ok(())
-    }
-
     fn scrape_target_dir_config(&mut self) -> CargoResult<()> {
         if let Some(dir) = env::var_os("CARGO_TARGET_DIR") {
             *self.target_dir.borrow_mut() = Some(Filesystem::new(self.cwd.join(dir)));